package dao

import (
	"log"
	"time"
	"user_srv/basic/config"
	"user_srv/handler/model"
)

// SwipeService 滑动操作服务
// 负责处理用户的滑动（喜欢/无感）操作
type SwipeService struct{}

// ProcessSwipe 处理滑动操作
// 功能：记录用户的滑动操作，并在双向喜欢时创建匹配
// 核心逻辑：
//  1. 验证参数和权限
//  2. 检查是否已滑动过（防止重复滑动）
//  3. 检查目标用户是否存在
//  4. 记录滑动行为到数据库
//  5. 如果是"喜欢"操作，检查对方是否也喜欢自己
//  6. 如果是双向喜欢，创建匹配关系并发送通知
//
// 参数：
//   - userId: 当前用户ID
//   - targetUserId: 目标用户ID
//   - action: 滑动动作（0=无感，1=喜欢）
//
// 返回值：SwipeResult 包含操作结果、是否匹配、匹配ID等信息
func (s *SwipeService) ProcessSwipe(userId, targetUserId int64, action int8) (*SwipeResult, error) {
	// 验证参数
	if userId <= 0 || targetUserId <= 0 {
		return nil, ErrInvalidUserId
	}
	if userId == targetUserId {
		return nil, ErrCannotSwipeSelf
	}
	if action != 0 && action != 1 {
		return nil, ErrInvalidAction
	}

	// 检查是否已经滑动过
	var swipeModel model.XqUserSwipes
	if swipeModel.HasSwiped(userId, targetUserId) {
		return nil, ErrAlreadySwiped
	}

	// 检查目标用户是否存在
	var targetProfile model.XqUserProfiles
	err := config.DB.Where("user_id = ? AND is_active = 1", targetUserId).First(&targetProfile).Error
	if err != nil {
		return nil, ErrTargetUserNotFound
	}

	// 记录滑动行为
	swipe := model.XqUserSwipes{
		UserId:       userId,
		TargetUserId: targetUserId,
		Action:       action,
		CreatedAt:    time.Now(),
	}
	err = swipe.Create()
	if err != nil {
		return nil, err
	}

	result := &SwipeResult{
		Success: true,
		IsMatch: false,
		Message: "滑动操作记录成功",
	}

	// 如果是喜欢操作，检查是否双向匹配
	if action == 1 {
		isMatch, err := s.checkMutualLike(userId, targetUserId)
		if err != nil {
			return nil, err
		}

		if isMatch {
			// 创建匹配关系
			matchId, err := s.createMatch(userId, targetUserId)
			if err != nil {
				return nil, err
			}

			result.IsMatch = true
			result.MatchId = matchId
			result.Message = "恭喜！你们互相喜欢，匹配成功！"

			// 发送匹配通知
			err = s.sendMatchNotification(userId, targetUserId, matchId)
			if err != nil {
				// 通知发送失败不影响匹配结果，只记录日志
				log.Printf("发送匹配通知失败: %v", err)
			}

			// 发送WebSocket实时通知（如果API Gateway可用）
			go s.sendWebSocketMatchNotification(userId, targetUserId, matchId)
		}
	}

	return result, nil
}

// checkMutualLike 检查是否双向喜欢
// 功能：检查对方是否也喜欢自己（是否对自己有过"喜欢"滑动）
// 返回值：true表示双向喜欢，false表示单向喜欢
func (s *SwipeService) checkMutualLike(userId, targetUserId int64) (bool, error) {
	var swipe model.XqUserSwipes
	err := config.DB.Where("user_id = ? AND target_user_id = ? AND action = 1", targetUserId, userId).First(&swipe).Error
	if err != nil {
		// 如果查询失败，说明对方还没有喜欢当前用户
		return false, nil
	}
	return true, nil
}

// createMatch 创建匹配关系
// 功能：在双方互相喜欢时创建匹配记录
// 设计优化：确保userId1 < userId2，避免重复匹配
// 参数：
//   - userId1, userId2: 两个用户ID（会自动排序）
//
// 返回值：匹配记录ID
func (s *SwipeService) createMatch(userId1, userId2 int64) (int64, error) {
	// 确保user_id1 < user_id2，避免重复匹配
	if userId1 > userId2 {
		userId1, userId2 = userId2, userId1
	}

	match := model.XqUserMatches{
		UserId1:   userId1,
		UserId2:   userId2,
		MatchTime: time.Now(),
		IsActive:  1,
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}

	err := match.Create()
	if err != nil {
		return 0, err
	}

	return match.Id, nil
}

// GetUserMatches 获取用户的匹配列表
// 功能：获取当前用户的所有匹配记录（用于聊天列表）
// 返回信息：
//   - 匹配用户的昵称、头像
//   - 最后一条消息内容和时间
//   - 匹配时间
//
// 参数：
//   - userId: 用户ID
//   - page: 页码
//   - pageSize: 每页数量
//
// 返回值：匹配列表和总记录数
func (s *SwipeService) GetUserMatches(userId int64, page, pageSize int32) ([]MatchInfo, int32, error) {
	// 设置默认值
	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 {
		pageSize = 10
	}
	if pageSize > 50 {
		pageSize = 50
	}

	offset := (page - 1) * pageSize

	// 获取匹配记录
	var matchModel model.XqUserMatches
	matches, err := matchModel.ListByUserId(userId, int(pageSize), int(offset))
	if err != nil {
		return nil, 0, err
	}

	// 获取总数
	var total int64
	err = config.DB.Model(&model.XqUserMatches{}).Where("(user_id1 = ? OR user_id2 = ?) AND is_active = 1", userId, userId).Count(&total).Error
	if err != nil {
		return nil, 0, err
	}

	// 构建匹配信息
	var matchInfos []MatchInfo
	for _, match := range matches {
		// 获取匹配的另一方用户信息
		matchedUserId := match.GetMatchedUserId(userId)
		profile, err := s.getUserProfile(matchedUserId)
		if err != nil {
			continue
		}

		// 获取最后一条消息
		//var messageModel mobile.XqChatMessages
		lastMessage, err := s.getLastMessageByMatchId(match.Id)
		if err != nil {
			// 如果没有消息，使用默认值
			lastMessage = &model.XqChatMessages{
				Content:   "开始聊天吧！",
				CreatedAt: match.MatchTime,
			}
		}

		matchInfo := MatchInfo{
			MatchId:         match.Id,
			UserId:          matchedUserId,
			Nickname:        profile.Nickname,
			Avatar:          profile.Avatar,
			LastMessage:     lastMessage.Content,
			LastMessageTime: lastMessage.CreatedAt.Unix(),
			MatchTime:       match.MatchTime.Unix(),
		}

		matchInfos = append(matchInfos, matchInfo)
	}

	return matchInfos, int32(total), nil
}

// GetMatchDetail 获取匹配详情
// 功能：获取特定匹配的详细信息
// 包含信息：
//   - 匹配用户的详细信息（昵称、头像、简介）
//   - 用户兴趣标签
//   - 匹配时间
//
// 参数：
//   - userId: 当前用户ID
//   - matchId: 匹配记录ID
func (s *SwipeService) GetMatchDetail(userId, matchId int64) (*MatchDetailInfo, error) {
	// 验证匹配关系
	var matchModel model.XqUserMatches
	match, err := matchModel.GetByMatchId(matchId)
	if err != nil {
		return nil, ErrMatchNotFound
	}

	// 验证用户是否参与了这个匹配
	if match.UserId1 != userId && match.UserId2 != userId {
		return nil, ErrMatchNotFound
	}

	// 获取匹配的另一方用户信息
	matchedUserId := match.GetMatchedUserId(userId)
	profile, err := s.getUserProfile(matchedUserId)
	if err != nil {
		return nil, err
	}

	// 获取用户兴趣标签
	interests, err := s.getUserInterests(matchedUserId)
	if err != nil {
		return nil, err
	}

	detail := &MatchDetailInfo{
		MatchId:   match.Id,
		UserId:    matchedUserId,
		Nickname:  profile.Nickname,
		Avatar:    profile.Avatar,
		Bio:       profile.Bio,
		Interests: interests,
		MatchTime: match.MatchTime.Unix(),
	}

	return detail, nil
}

// 获取用户资料
func (s *SwipeService) getUserProfile(userId int64) (*model.XqUserProfiles, error) {
	var profileModel model.XqUserProfiles
	return profileModel.GetByUserId(userId)
}

// 获取用户兴趣标签名称
func (s *SwipeService) getUserInterests(userId int64) ([]string, error) {
	var interests []model.XqUserInterests
	err := config.DB.Where("user_id = ?", userId).Find(&interests).Error
	if err != nil {
		return nil, err
	}

	var tagIds []int64
	for _, interest := range interests {
		tagIds = append(tagIds, interest.TagId)
	}

	if len(tagIds) == 0 {
		return []string{}, nil
	}

	var tags []model.XqInterestTags
	err = config.DB.Where("id IN (?)", tagIds).Find(&tags).Error
	if err != nil {
		return nil, err
	}

	var tagNames []string
	for _, tag := range tags {
		tagNames = append(tagNames, tag.Name)
	}

	return tagNames, nil
}

// 获取匹配的最后一条消息
func (s *SwipeService) getLastMessageByMatchId(matchId int64) (*model.XqChatMessages, error) {
	var message model.XqChatMessages
	err := config.DB.Where("match_id = ?", matchId).Order("created_at DESC").First(&message).Error
	return &message, err
}

// 发送匹配通知
func (s *SwipeService) sendMatchNotification(userId1, userId2, matchId int64) error {
	var notificationService NotificationService
	return notificationService.SendMatchNotification(userId1, userId2, matchId)
}

// 发送WebSocket匹配通知
func (s *SwipeService) sendWebSocketMatchNotification(userId1, userId2, matchId int64) {
	// 这里可以通过HTTP请求通知API Gateway发送WebSocket消息
	// 或者使用消息队列等方式
	// 由于架构限制，这里暂时只记录日志
	// log.Printf("匹配成功，用户%d和用户%d，匹配ID: %d", userId1, userId2, matchId)
}

// SwipeResult 滑动结果结构体
// 返回滑动操作的执行结果
// - Success: 操作是否成功
// - IsMatch: 是否匹配成功（双向喜欢）
// - MatchId: 匹配记录ID（如果匹配成功）
// - Message: 操作结果信息
type SwipeResult struct {
	Success bool   `json:"success"`
	IsMatch bool   `json:"is_match"`
	MatchId int64  `json:"match_id,omitempty"`
	Message string `json:"message"`
}

// MatchInfo 匹配信息结构体
// 用于聊天列表展示
// - MatchId: 匹配记录ID
// - UserId: 匹配用户ID
// - Nickname: 昵称
// - Avatar: 头像
// - LastMessage: 最后一条消息
// - LastMessageTime: 最后消息时间
// - MatchTime: 匹配时间
type MatchInfo struct {
	MatchId         int64  `json:"match_id"`
	UserId          int64  `json:"user_id"`
	Nickname        string `json:"nickname"`
	Avatar          string `json:"avatar"`
	LastMessage     string `json:"last_message"`
	LastMessageTime int64  `json:"last_message_time"`
	MatchTime       int64  `json:"match_time"`
}

// MatchDetailInfo 匹配详情结构体
// 用于展示匹配的详细信息
// - MatchId: 匹配记录ID
// - UserId: 匹配用户ID
// - Nickname: 昵称
// - Avatar: 头像
// - Bio: 个人简介
// - Interests: 兴趣标签列表
// - MatchTime: 匹配时间
type MatchDetailInfo struct {
	MatchId   int64    `json:"match_id"`
	UserId    int64    `json:"user_id"`
	Nickname  string   `json:"nickname"`
	Avatar    string   `json:"avatar"`
	Bio       string   `json:"bio"`
	Interests []string `json:"interests"`
	MatchTime int64    `json:"match_time"`
}
